Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>Optimierungsmodell</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/Optimierungsmodell"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.math.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Optimierungsmodell rootpage-Optimierungsmodell skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">Optimierungsmodell</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><p>Ein <b>Optimierungsmodell</b> ist ein <a href="Mathematisches_Modell" title="Mathematisches Modell">mathematisches Modell</a>, welches einen zu <a href="Mathematische_Optimierung" title="Mathematische Optimierung">optimierenden</a> Sachverhalt beschreibt und aus Daten, <a href="Entscheidungsvariable" class="mw-redirect" title="Entscheidungsvariable">Entscheidungsvariablen</a>, einer <a href="Zielfunktion" class="mw-redirect" title="Zielfunktion">Zielfunktion</a> und einer <a href="Zul%C3%A4ssige_Menge" class="mw-redirect" title="Zulässige Menge">zulässigen Menge</a> besteht.
</p>

<div class="mw-heading mw-heading2"><h2 id="Abgrenzung_zu_Optimierungsproblem">Abgrenzung zu Optimierungsproblem</h2></div>
<p>Die Abgrenzung eines Optimierungsmodells zu einem <a href="Optimierungsproblem" title="Optimierungsproblem">Optimierungsproblem</a> wird in der Literatur nicht trennscharf vollzogen. Bei einem Optimierungs<i>modell</i> liegt jedoch der Schwerpunkt auf der Modellbildung, da es in der Regel zahlreiche Möglichkeiten gibt, ein Anwendungsproblem zu modellieren und die Modellierung selbst ein Schritt ist, der bestmöglich vollzogen werden sollte.<sup id="cite_ref-:0_1-0" class="reference"><a href="#cite_note-:0-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> So gibt es etwa viele Optimierungsmodelle, die das <a href="Problem_des_Handlungsreisenden" title="Problem des Handlungsreisenden">Problem des Handlungsreisenden</a> darstellen, die jeweils unterschiedliche Vor- und Nachteile haben.<sup id="cite_ref-:1_2-0" class="reference"><a href="#cite_note-:1-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Ziele_guter_Modellierung">Ziele guter Modellierung</h2></div>
<p>Das Ergebnis der Modellbildung in der mathematischen Optimierung ist ein Optimierungsmodell. Dieses wird anschließend von einem <i><a href="Solver" title="Solver">Solver</a></i> gelöst, welcher eine optimale Lösung des Optimierungsmodells berechnet und damit eine Lösung des zugrundeliegenden Problems bereitstellt. Um aus Anwendungssicht ein zufriedenstellendes Ergebnis zu erreichen, sind die Ziele guter Modellierung demzufolge
</p>
<ul><li>das zu lösende Anwendungsproblem mit ausreichend hoher Genauigkeit zu beschreiben und</li>
<li>ein Optimierungsmodell zu erstellen, welches anschließend mit der zur Verfügung stehenden Software und Rechenleistung ausreichend schnell gelöst werden kann.</li></ul>
<p>Weitere Ziele sind etwa die Lesbarkeit der mathematischen Formulierung oder die Wiederverwertbarkeit der Implementierung.
</p><p>Ob das Optimierungsmodell den Anwendungsfall ausreichend genau beschreibt, stellt sich in der Regel durch eine Diskussion der Ergebnisse mit den jeweiligen Anwenderinnen heraus. Dies ist in der Regel ein iterativer Prozess, weshalb frühzeitig Feedback eingeholt werden sollte.<sup id="cite_ref-:2_3-0" class="reference"><a href="#cite_note-:2-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>
</p><p>Die Auswirkungen verschiedener Modellierungsvarianten auf die Laufzeit des Solvers sind a priori oft schwer einzuschätzen, was unter anderem daran liegt, das kommerzielle Solver-Implementierungen nicht offen einsehbar sind und etwa durch umfangreiche Presolve-Techniken Umformulierungen der ursprünglichen Formulierung durchführen werden<sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>. Grundsätzlich gibt es in der <a href="Gemischt-ganzzahlige_Optimierung" title="Gemischt-ganzzahlige Optimierung">gemischt-ganzzahligen Optimierung</a> einen Trade-Off zwischen möglichst <i>engen</i> (eng. <i>tight</i>) Formulierungen – d.&nbsp;h. ganzzahligen Formulierungen, deren kontinuierliche Relaxierung die <a href="Konvexe_H%C3%BClle" title="Konvexe Hülle">konvexe Hülle</a> der zulässigen Punkte möglichst eng einschließt – und <i>kompakten</i> Formulierungen, d.&nbsp;h. Modellen mit möglichst wenigen Variablen und Nebenbedingungen. Diese beiden Ziele sind in der Regel konfliktär, da etwa durch die Einführung zusätzlicher Nebenbedingungen (auch <i>Cuts</i>) engere Formulierungen erreicht werden können.<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Beispiele_für_gute_und_schlechte_Modellierung"><span id="Beispiele_f.C3.BCr_gute_und_schlechte_Modellierung"></span>Beispiele für gute und schlechte Modellierung</h2></div>
<p>Gesucht ist eine Formulierung des <a href="Sudoku" title="Sudoku">Sudoku</a>-Spiels als Optimierungsmodell. Seien zunächst <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle R=\{1,\ldots ,9\}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>R</mi>
<mo>=</mo>
<mo fence="false" stretchy="false">{</mo>
<mn>1</mn>
<mo>,</mo>
<mo>…<!-- … --></mo>
<mo>,</mo>
<mn>9</mn>
<mo fence="false" stretchy="false">}</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle R=\{1,\ldots ,9\}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/e18e40c2dc226e7586204c793f34d7b387835f27.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:14.691ex; height:2.843ex;" alt="{\displaystyle R=\{1,\ldots ,9\}}" loading="lazy"></span> und <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle C=\{1,\ldots ,9\}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>C</mi>
<mo>=</mo>
<mo fence="false" stretchy="false">{</mo>
<mn>1</mn>
<mo>,</mo>
<mo>…<!-- … --></mo>
<mo>,</mo>
<mn>9</mn>
<mo fence="false" stretchy="false">}</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle C=\{1,\ldots ,9\}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/03d473a7ea89d6eb687307a63bc3ac2115fe499c.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:14.693ex; height:2.843ex;" alt="{\displaystyle C=\{1,\ldots ,9\}}" loading="lazy"></span> die Menge der Zeilen bzw. Spalten des Sudokus und <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle B\ =\ {\big \{}\{(3i+k,3j+l)|\ k,l\in \{1,2,3\}|\ i,j\in \{0,1,2\}\}{\big \}}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>B</mi>
<mtext>&nbsp;</mtext>
<mo>=</mo>
<mtext>&nbsp;</mtext>
<mrow class="MJX-TeXAtom-ORD">
<mrow class="MJX-TeXAtom-ORD">
<mo maxsize="1.2em" minsize="1.2em">{</mo>
</mrow>
</mrow>
<mo fence="false" stretchy="false">{</mo>
<mo stretchy="false">(</mo>
<mn>3</mn>
<mi>i</mi>
<mo>+</mo>
<mi>k</mi>
<mo>,</mo>
<mn>3</mn>
<mi>j</mi>
<mo>+</mo>
<mi>l</mi>
<mo stretchy="false">)</mo>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mtext>&nbsp;</mtext>
<mi>k</mi>
<mo>,</mo>
<mi>l</mi>
<mo>∈<!-- ∈ --></mo>
<mo fence="false" stretchy="false">{</mo>
<mn>1</mn>
<mo>,</mo>
<mn>2</mn>
<mo>,</mo>
<mn>3</mn>
<mo fence="false" stretchy="false">}</mo>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mtext>&nbsp;</mtext>
<mi>i</mi>
<mo>,</mo>
<mi>j</mi>
<mo>∈<!-- ∈ --></mo>
<mo fence="false" stretchy="false">{</mo>
<mn>0</mn>
<mo>,</mo>
<mn>1</mn>
<mo>,</mo>
<mn>2</mn>
<mo fence="false" stretchy="false">}</mo>
<mo fence="false" stretchy="false">}</mo>
<mrow class="MJX-TeXAtom-ORD">
<mrow class="MJX-TeXAtom-ORD">
<mo maxsize="1.2em" minsize="1.2em">}</mo>
</mrow>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle B\ =\ {\big \{}\{(3i+k,3j+l)|\ k,l\in \{1,2,3\}|\ i,j\in \{0,1,2\}\}{\big \}}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/dd78aec6946ab9233e43e11d960296b039f7ea25.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:55.203ex; height:3.176ex;" alt="{\displaystyle B\ =\ {\big \{}\{(3i+k,3j+l)|\ k,l\in \{1,2,3\}|\ i,j\in \{0,1,2\}\}{\big \}}}" loading="lazy"></span> die Menge der 3x3-Boxen. Da hier lediglich eine zulässige Lösung gesucht ist, spielt die Zielfunktion keine Rolle. Es gibt nun verschiedene Möglichkeiten, mit der Modellierung fortzufahren. Die dargestellten Varianten sind der Literatur entnommen und auch die zugehörigen Python-Codes sind online verfügbar.<sup id="cite_ref-:0_1-1" class="reference"><a href="#cite_note-:0-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>
Zunächst werden die Pakete itertools und Python-MIP<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> importiert. Letzteres kann mit dem freien Open-Source Solver CBC („COIN-OR Branch-and-Cut“) oder mit dem kommerziellen Solver <a href="Gurobi" title="Gurobi">Gurobi</a> verwendet werden.</p><div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre><span></span><span class="kn">from</span><span class="w"> </span><span class="nn">itertools</span><span class="w"> </span><span class="kn">import</span> <span class="n">combinations</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">mip</span><span class="w"> </span><span class="kn">import</span> <span class="n">BINARY</span><span class="p">,</span> <span class="n">CBC</span><span class="p">,</span> <span class="n">GUROBI</span><span class="p">,</span> <span class="n">INTEGER</span><span class="p">,</span> <span class="n">Model</span>
</pre></div><p>Anschließend wird der Solver gewählt, die initialen Werte des Sudokus übergeben und die Zeilen, Spalten und Boxen definiert. Das Dictionary <code>init_vals</code> wird je nach Sudoku mit den Werten befüllt, die bereits in das Sudokufeld eingetragen wurden.
</p><div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre><span></span><span class="c1"># Choose CBC or Gurobi</span>
<span class="n">solver_name</span> <span class="o">=</span> <span class="n">CBC</span>
<span class="c1"># Todo: provide initial values in the format (r, c): v</span>
<span class="n">init_vals</span> <span class="o">=</span> <span class="p">{}</span>

<span class="c1"># Needed data structures</span>
<span class="n">rows</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
<span class="n">columns</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
<span class="n">boxes</span> <span class="o">=</span> <span class="p">[</span>
<span class="p">[</span>
<span class="p">(</span><span class="mi">3</span> <span class="o">*</span> <span class="n">i</span> <span class="o">+</span> <span class="n">k</span><span class="p">,</span> <span class="mi">3</span> <span class="o">*</span> <span class="n">j</span> <span class="o">+</span> <span class="n">l</span><span class="p">)</span>
<span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="k">for</span> <span class="n">l</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="p">]</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="p">]</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Ein_schlechtes_Sudoku-Modell">Ein schlechtes Sudoku-Modell</h3></div>
<p>Ein intuitiver Ansatz wäre es, für jedes Sudoku-Feld eine ganzzahlige <i>Entscheidungsvariable</i> <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x_{rc}\in \{1,\ldots ,9\}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
</mrow>
</msub>
<mo>∈<!-- ∈ --></mo>
<mo fence="false" stretchy="false">{</mo>
<mn>1</mn>
<mo>,</mo>
<mo>…<!-- … --></mo>
<mo>,</mo>
<mn>9</mn>
<mo fence="false" stretchy="false">}</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x_{rc}\in \{1,\ldots ,9\}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/bc10f2b573d37b49df85cf31c9a1e1c685737423.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:15.684ex; height:2.843ex;" alt="{\displaystyle x_{rc}\in \{1,\ldots ,9\}}" loading="lazy"></span> einzuführen, welche angibt, welche Zahl in das Feld <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle (r,c),\ r\in R,\ c\in C,}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mo stretchy="false">(</mo>
<mi>r</mi>
<mo>,</mo>
<mi>c</mi>
<mo stretchy="false">)</mo>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<mi>r</mi>
<mo>∈<!-- ∈ --></mo>
<mi>R</mi>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<mi>c</mi>
<mo>∈<!-- ∈ --></mo>
<mi>C</mi>
<mo>,</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle (r,c),\ r\in R,\ c\in C,}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/3061995ebb8cf6a9b1926858a2ef5eae0f43ba79.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:20.042ex; height:2.843ex;" alt="{\displaystyle (r,c),\ r\in R,\ c\in C,}" loading="lazy"></span> der Reihe <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle r}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>r</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle r}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/0d1ecb613aa2984f0576f70f86650b7c2a132538.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.049ex; height:1.676ex;" alt="{\displaystyle r}" loading="lazy"></span> und Spalte <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle c}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>c</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle c}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/86a67b81c2de995bd608d5b2df50cd8cd7d92455.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.007ex; height:1.676ex;" alt="{\displaystyle c}" loading="lazy"></span> einzutragen sind. So würde etwa <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x_{2,4}=5}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>2</mn>
<mo>,</mo>
<mn>4</mn>
</mrow>
</msub>
<mo>=</mo>
<mn>5</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x_{2,4}=5}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/fe4d38a9b9f8542ab2fd07923a6bcf1e386d40c6.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:7.924ex; height:2.843ex;" alt="{\displaystyle x_{2,4}=5}" loading="lazy"></span> bedeuten, dass in der zweiten Zeile und vierten Spalte die Zahl fünf eingetragen wird.
</p><p>Bei den <i>Nebenbedingungen</i> werden nun im Beispiel des nebenstehenden Sudokus zunächst mit <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x_{1,1}=5,\ x_{1,2}=3,\ \ldots ,\ x_{9,9}=9}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>1</mn>
<mo>,</mo>
<mn>1</mn>
</mrow>
</msub>
<mo>=</mo>
<mn>5</mn>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>1</mn>
<mo>,</mo>
<mn>2</mn>
</mrow>
</msub>
<mo>=</mo>
<mn>3</mn>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<mo>…<!-- … --></mo>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>9</mn>
<mo>,</mo>
<mn>9</mn>
</mrow>
</msub>
<mo>=</mo>
<mn>9</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x_{1,1}=5,\ x_{1,2}=3,\ \ldots ,\ x_{9,9}=9}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/1d38ba6752fe5067b3f6b8db33e993b3e8411c12.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:32.114ex; height:2.843ex;" alt="{\displaystyle x_{1,1}=5,\ x_{1,2}=3,\ \ldots ,\ x_{9,9}=9}" loading="lazy"></span> alle Variablen fixiert, für die bereits Zahlen in die entsprechenden Felder wurden.
</p><p>Außerdem sollen sich die Einträge pro Zeile, Spalte und Box unterscheiden. Die Variablen <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x_{rc}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
</mrow>
</msub>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x_{rc}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/14a40314c7ccd78a17f265c0ec12359b53150a2a.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:3.015ex; height:2.009ex;" alt="{\displaystyle x_{rc}}" loading="lazy"></span> und <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x_{r'c'}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<msup>
<mi>r</mi>
<mo>′</mo>
</msup>
<msup>
<mi>c</mi>
<mo>′</mo>
</msup>
</mrow>
</msub>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x_{r'c'}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/7dfd77474f836e2d53dd99ec56cc0f3b917f6bcc.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:4.079ex; height:2.009ex;" alt="{\displaystyle x_{r'c'}}" loading="lazy"></span> unterscheiden sich genau dann, wenn gilt <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle |x_{rc}-x_{r'c'}|\ \geq \ 1}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
</mrow>
</msub>
<mo>−<!-- − --></mo>
<msub>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<msup>
<mi>r</mi>
<mo>′</mo>
</msup>
<msup>
<mi>c</mi>
<mo>′</mo>
</msup>
</mrow>
</msub>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mtext>&nbsp;</mtext>
<mo>≥<!-- ≥ --></mo>
<mtext>&nbsp;</mtext>
<mn>1</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle |x_{rc}-x_{r'c'}|\ \geq \ 1}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/db497778d7b5e284019bb35048504a0e962b5e1b.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:16.65ex; height:2.843ex;" alt="{\displaystyle |x_{rc}-x_{r'c'}|\ \geq \ 1}" loading="lazy"></span>, wobei hier sehr viele Kombinationen von Indexpaaren <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle (r,c)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mo stretchy="false">(</mo>
<mi>r</mi>
<mo>,</mo>
<mi>c</mi>
<mo stretchy="false">)</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle (r,c)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/f0b15aba99d8ec680a81a3acc2e82a5edd20971c.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:4.899ex; height:2.843ex;" alt="{\displaystyle (r,c)}" loading="lazy"></span> und <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle (r',c')}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mo stretchy="false">(</mo>
<msup>
<mi>r</mi>
<mo>′</mo>
</msup>
<mo>,</mo>
<msup>
<mi>c</mi>
<mo>′</mo>
</msup>
<mo stretchy="false">)</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle (r',c')}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/ef241bb326901578264ed0ae6b7dfb9e68dcbddf.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:6.268ex; height:3.009ex;" alt="{\displaystyle (r',c')}" loading="lazy"></span> untersucht werden müssen. Für kommerzielle Solver kann diese nichtlineare Nebenbedingung genau so formuliert werden. Für Open-Source-Frameworks müsste diese Constraint unter Einführung vieler Hilfsvariablen <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle a_{rcr'c'}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>a</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
<msup>
<mi>r</mi>
<mo>′</mo>
</msup>
<msup>
<mi>c</mi>
<mo>′</mo>
</msup>
</mrow>
</msub>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle a_{rcr'c'}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/d3d4e6e8ea70989acbbd641e584b14f929bd5d95.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:5.432ex; height:2.009ex;" alt="{\displaystyle a_{rcr'c'}}" loading="lazy"></span> weiter umformuliert werden.
</p><p>Hier ist die zugehörige Python-Implementierung.
</p>
<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre><span></span><span class="c1"># Model declaration</span>
<span class="n">m</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="s2">"Sudoku integer"</span><span class="p">,</span> <span class="n">solver_name</span><span class="o">=</span><span class="n">solver_name</span><span class="p">)</span>

<span class="c1"># Decision variables</span>
<span class="n">x</span> <span class="o">=</span> <span class="p">{</span>
<span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">):</span> <span class="n">m</span><span class="o">.</span><span class="n">add_var</span><span class="p">(</span><span class="n">var_type</span><span class="o">=</span><span class="n">INTEGER</span><span class="p">,</span> <span class="n">lb</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">ub</span><span class="o">=</span><span class="mi">9</span><span class="p">)</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span>
<span class="p">}</span>
<span class="n">y</span> <span class="o">=</span> <span class="p">{</span>
<span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">r1</span><span class="p">,</span> <span class="n">c1</span><span class="p">):</span> <span class="n">m</span><span class="o">.</span><span class="n">add_var</span><span class="p">(</span><span class="n">var_type</span><span class="o">=</span><span class="n">BINARY</span><span class="p">)</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span>
<span class="k">for</span> <span class="n">r1</span> <span class="ow">in</span> <span class="n">rows</span>
<span class="k">for</span> <span class="n">c1</span> <span class="ow">in</span> <span class="n">columns</span>
<span class="p">}</span>

<span class="c1"># Constraints</span>
<span class="c1"># Respect initial values</span>
<span class="k">for</span> <span class="p">((</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">),</span> <span class="n">v</span><span class="p">)</span> <span class="ow">in</span> <span class="n">init_vals</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">==</span> <span class="n">v</span>
<span class="c1"># Unique value per row</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span><span class="p">:</span>
<span class="k">for</span> <span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">c1</span><span class="p">)</span> <span class="ow">in</span> <span class="n">combinations</span><span class="p">(</span><span class="n">columns</span><span class="p">,</span> <span class="mi">2</span><span class="p">):</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">&lt;=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c1</span><span class="p">]</span> <span class="o">+</span> <span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">r</span><span class="p">,</span> <span class="n">c1</span><span class="p">]</span> <span class="o">*</span> <span class="mi">9</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c1</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">-</span> <span class="p">(</span><span class="mi">1</span> <span class="o">-</span> <span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">r</span><span class="p">,</span> <span class="n">c1</span><span class="p">])</span> <span class="o">*</span> <span class="mi">9</span>
<span class="c1"># Unique value per column</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span><span class="p">:</span>
<span class="k">for</span> <span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">r1</span><span class="p">)</span> <span class="ow">in</span> <span class="n">combinations</span><span class="p">(</span><span class="n">rows</span><span class="p">,</span> <span class="mi">2</span><span class="p">):</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">&lt;=</span> <span class="n">x</span><span class="p">[</span><span class="n">r1</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">+</span> <span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">r1</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">*</span> <span class="mi">9</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="n">x</span><span class="p">[</span><span class="n">r1</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">-</span> <span class="p">(</span><span class="mi">1</span> <span class="o">-</span> <span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">r1</span><span class="p">,</span> <span class="n">c</span><span class="p">])</span> <span class="o">*</span> <span class="mi">9</span>
<span class="c1"># Unique value per box</span>
<span class="k">for</span> <span class="n">box</span> <span class="ow">in</span> <span class="n">boxes</span><span class="p">:</span>
<span class="k">for</span> <span class="p">((</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">),</span> <span class="p">(</span><span class="n">r1</span><span class="p">,</span> <span class="n">c1</span><span class="p">))</span> <span class="ow">in</span> <span class="n">combinations</span><span class="p">(</span><span class="n">box</span><span class="p">,</span> <span class="mi">2</span><span class="p">):</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">&lt;=</span> <span class="n">x</span><span class="p">[</span><span class="n">r1</span><span class="p">,</span> <span class="n">c1</span><span class="p">]</span> <span class="o">+</span> <span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">r1</span><span class="p">,</span> <span class="n">c1</span><span class="p">]</span> <span class="o">*</span> <span class="mi">9</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="n">x</span><span class="p">[</span><span class="n">r1</span><span class="p">,</span> <span class="n">c1</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">-</span> <span class="p">(</span><span class="mi">1</span> <span class="o">-</span> <span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">r1</span><span class="p">,</span> <span class="n">c1</span><span class="p">])</span> <span class="o">*</span> <span class="mi">9</span>

<span class="c1"># Optimize statement</span>
<span class="n">m</span><span class="o">.</span><span class="n">optimize</span><span class="p">()</span>
</pre></div><p>Das resultierende Sudoku kann anschließend ausgegeben werden. Man beachte, dass obige Formulierung nur mit Gurobi in angemessener Zeit lösbar ist.</p><div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre><span></span><span class="c1"># Print solution</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span><span class="p">:</span>
<span class="k">if</span> <span class="p">(</span><span class="n">r</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"+-------+-------+-------+"</span><span class="p">)</span>
<span class="n">line</span> <span class="o">=</span> <span class="s2">""</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span><span class="p">:</span>
<span class="k">if</span> <span class="p">(</span><span class="n">c</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">line</span> <span class="o">+=</span> <span class="s2">"| "</span>
<span class="n">line</span> <span class="o">+=</span> <span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="nb">int</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">r</span><span class="p">,</span><span class="w"> </span><span class="n">c</span><span class="p">]</span><span class="o">.</span><span class="n">x</span><span class="p">)</span><span class="si">}</span><span class="s2"> "</span>
<span class="k">if</span> <span class="n">c</span> <span class="o">==</span> <span class="mi">9</span><span class="p">:</span>
<span class="n">line</span> <span class="o">+=</span> <span class="s2">"|"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"+-------+-------+-------+"</span><span class="p">)</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Ein_gutes_Sudoku-Modell">Ein gutes Sudoku-Modell</h3></div><p>
Alternativ kann ein Ansatz gewählt werden, der im <a href="Data_Science" title="Data Science">Data Science</a> unter dem Begriff <i>One-Hot Encoding</i> bekannt ist. Es wird für jede Kombination aus Zeile <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle r\in R}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>r</mi>
<mo>∈<!-- ∈ --></mo>
<mi>R</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle r\in R}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/ca49c66b5e9b5f32249a737e4429c3df136c33f0.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:5.653ex; height:2.176ex;" alt="{\displaystyle r\in R}" loading="lazy"></span>, Spalte <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle c\in C}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>c</mi>
<mo>∈<!-- ∈ --></mo>
<mi>C</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle c\in C}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/447d3982c94c23d6b6d01c90da81a6125aa26567.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:5.614ex; height:2.176ex;" alt="{\displaystyle c\in C}" loading="lazy"></span> und Wert <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle v\in V:=\{1,\ldots ,9\}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>v</mi>
<mo>∈<!-- ∈ --></mo>
<mi>V</mi>
<mo>:=</mo>
<mo fence="false" stretchy="false">{</mo>
<mn>1</mn>
<mo>,</mo>
<mo>…<!-- … --></mo>
<mo>,</mo>
<mn>9</mn>
<mo fence="false" stretchy="false">}</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle v\in V:=\{1,\ldots ,9\}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/cd13c27be2727fb2a93028eab348b431956d7a46.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:19.329ex; height:2.843ex;" alt="{\displaystyle v\in V:=\{1,\ldots ,9\}}" loading="lazy"></span> keine beliebige ganzzahlige, sondern eine <i>binäre</i> Entscheidungsvariable <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle y_{rcv}\in \{0,1\},\ r\in R,\ c\in C,\ v\in V}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
<mi>v</mi>
</mrow>
</msub>
<mo>∈<!-- ∈ --></mo>
<mo fence="false" stretchy="false">{</mo>
<mn>0</mn>
<mo>,</mo>
<mn>1</mn>
<mo fence="false" stretchy="false">}</mo>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<mi>r</mi>
<mo>∈<!-- ∈ --></mo>
<mi>R</mi>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<mi>c</mi>
<mo>∈<!-- ∈ --></mo>
<mi>C</mi>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<mi>v</mi>
<mo>∈<!-- ∈ --></mo>
<mi>V</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle y_{rcv}\in \{0,1\},\ r\in R,\ c\in C,\ v\in V}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/d5405f077711471b480fc9abbf4f0a080c3b486f.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:34.013ex; height:2.843ex;" alt="{\displaystyle y_{rcv}\in \{0,1\},\ r\in R,\ c\in C,\ v\in V}" loading="lazy"></span> mit folgender Interpretation ein. Falls <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle y_{rcv}=1}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
<mi>v</mi>
</mrow>
</msub>
<mo>=</mo>
<mn>1</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle y_{rcv}=1}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/0fcfa5bae8c7edc29850d667e606c8c5a403f6c5.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:7.883ex; height:2.509ex;" alt="{\displaystyle y_{rcv}=1}" loading="lazy"></span> gilt, steht der Wert <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle v}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>v</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle v}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/e07b00e7fc0847fbd16391c778d65bc25c452597.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.128ex; height:1.676ex;" alt="{\displaystyle v}" loading="lazy"></span> in Zeile <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle r}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>r</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle r}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/0d1ecb613aa2984f0576f70f86650b7c2a132538.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.049ex; height:1.676ex;" alt="{\displaystyle r}" loading="lazy"></span> und Spalte <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle c}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>c</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle c}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/86a67b81c2de995bd608d5b2df50cd8cd7d92455.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.007ex; height:1.676ex;" alt="{\displaystyle c}" loading="lazy"></span> und für <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\textstyle y_{rcv}=0}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="false" scriptlevel="0">
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
<mi>v</mi>
</mrow>
</msub>
<mo>=</mo>
<mn>0</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\textstyle y_{rcv}=0}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/a793a50f800ecb854da2f4c6d2183fe050ca510f.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:7.883ex; height:2.509ex;" alt="{\textstyle y_{rcv}=0}" loading="lazy"></span> nicht. Beispielsweise bedeutet <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\textstyle y_{2,4,5}=1}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="false" scriptlevel="0">
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>2</mn>
<mo>,</mo>
<mn>4</mn>
<mo>,</mo>
<mn>5</mn>
</mrow>
</msub>
<mo>=</mo>
<mn>1</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\textstyle y_{2,4,5}=1}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/f64181ce5282722702e4f15cd02f652fdf3da0c6.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:9.013ex; height:2.843ex;" alt="{\textstyle y_{2,4,5}=1}" loading="lazy"></span>, dass in der zweiten Zeile und vierten Spalte der Wert fünf eingetragen wird. Dass etwa pro Spalte jeder Wert nur ein Mal vorkommen darf, wird über <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\textstyle \sum _{r\in R}y_{rcv}=1}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="false" scriptlevel="0">
<munder>
<mo>∑<!-- ∑ --></mo>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mo>∈<!-- ∈ --></mo>
<mi>R</mi>
</mrow>
</munder>
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
<mi>v</mi>
</mrow>
</msub>
<mo>=</mo>
<mn>1</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\textstyle \sum _{r\in R}y_{rcv}=1}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/a8e7190221795f695700a47eb24ad94837e277b2.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:14.041ex; height:3.009ex;" alt="{\textstyle \sum _{r\in R}y_{rcv}=1}" loading="lazy"></span> für alle Spalten <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle c\in C}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>c</mi>
<mo>∈<!-- ∈ --></mo>
<mi>C</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle c\in C}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/447d3982c94c23d6b6d01c90da81a6125aa26567.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:5.614ex; height:2.176ex;" alt="{\displaystyle c\in C}" loading="lazy"></span> und Werte <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle v\in V}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>v</mi>
<mo>∈<!-- ∈ --></mo>
<mi>V</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle v\in V}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/99886ebbde63daa0224fb9bf56fa11b3c8a6f4fb.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:5.756ex; height:2.176ex;" alt="{\displaystyle v\in V}" loading="lazy"></span> modelliert, da eine Summe von Binärvariablen genau dann eins ist, wenn eine der Binärvariablen eins und alle verbleibenden null sind. Die Bedingungen pro Zeile und Box können analog formuliert werden. Es ist nicht zu vergessen, dass in jedes Feld überhaupt ein Wert einzutragen ist, was über <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \sum _{v\in V}y_{rcv}\ =\ 1}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<munder>
<mo>∑<!-- ∑ --></mo>
<mrow class="MJX-TeXAtom-ORD">
<mi>v</mi>
<mo>∈<!-- ∈ --></mo>
<mi>V</mi>
</mrow>
</munder>
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>r</mi>
<mi>c</mi>
<mi>v</mi>
</mrow>
</msub>
<mtext>&nbsp;</mtext>
<mo>=</mo>
<mtext>&nbsp;</mtext>
<mn>1</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \sum _{v\in V}y_{rcv}\ =\ 1}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/325c6e9e2aefe3603c7cea7e98e2c5880851715a.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -3.171ex; width:12.787ex; height:5.676ex;" alt="{\displaystyle \sum _{v\in V}y_{rcv}\ =\ 1}" loading="lazy"></span> erzwungen wird.</p><div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre><span></span><span class="c1"># Model declaration</span>
<span class="n">m</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="s2">"Sudoku binary"</span><span class="p">,</span> <span class="n">solver_name</span><span class="o">=</span><span class="n">solver_name</span><span class="p">)</span>

<span class="c1"># Decision variables</span>
<span class="n">y</span> <span class="o">=</span> <span class="p">{</span>
<span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">v</span><span class="p">):</span> <span class="n">m</span><span class="o">.</span><span class="n">add_var</span><span class="p">(</span><span class="n">var_type</span><span class="o">=</span><span class="n">BINARY</span><span class="p">)</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span>
<span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">values</span>
<span class="p">}</span>

<span class="c1"># Constraints</span>
<span class="c1"># Respect initial values</span>
<span class="k">for</span> <span class="p">((</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">),</span> <span class="n">v</span><span class="p">)</span> <span class="ow">in</span> <span class="n">init_vals</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">v</span><span class="p">]</span> <span class="o">==</span> <span class="mi">1</span>
<span class="c1"># One entry per cell</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span><span class="p">:</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span><span class="p">:</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">xsum</span><span class="p">(</span><span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">v</span><span class="p">]</span> <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">values</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>
<span class="c1"># Unique value per row</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span><span class="p">:</span>
<span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">values</span><span class="p">:</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">xsum</span><span class="p">(</span><span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">v</span><span class="p">]</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>
<span class="c1"># Unique value per column</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span><span class="p">:</span>
<span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">values</span><span class="p">:</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">xsum</span><span class="p">(</span><span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">v</span><span class="p">]</span> <span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>
<span class="c1"># Unique value per box</span>
<span class="k">for</span> <span class="n">box</span> <span class="ow">in</span> <span class="n">boxes</span><span class="p">:</span>
<span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">values</span><span class="p">:</span>
<span class="n">m</span> <span class="o">+=</span> <span class="n">xsum</span><span class="p">(</span><span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">v</span><span class="p">]</span> <span class="k">for</span> <span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">)</span> <span class="ow">in</span> <span class="n">box</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span>

<span class="c1"># Optimize statement</span>
<span class="n">m</span><span class="o">.</span><span class="n">optimize</span><span class="p">()</span>
</pre></div><p>
Im Gegensatz zu obiger Formulierung kann diese auch von CBC innerhalb weniger Sekunden gelöst werden.</p><div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre><span></span><span class="c1"># Print solution</span>
<span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">rows</span><span class="p">:</span>
<span class="k">if</span> <span class="p">(</span><span class="n">r</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"+-------+-------+-------+"</span><span class="p">)</span>
<span class="n">line</span> <span class="o">=</span> <span class="s2">""</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">columns</span><span class="p">:</span>
<span class="k">if</span> <span class="p">(</span><span class="n">c</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">line</span> <span class="o">+=</span> <span class="s2">"| "</span>
<span class="n">val</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">y</span><span class="p">[</span><span class="n">r</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">v</span><span class="p">]</span><span class="o">.</span><span class="n">x</span> <span class="o">*</span> <span class="n">v</span> <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">values</span><span class="p">))</span>
<span class="n">line</span> <span class="o">+=</span> <span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">val</span><span class="si">}</span><span class="s2"> "</span>
<span class="k">if</span> <span class="n">c</span> <span class="o">==</span> <span class="mi">9</span><span class="p">:</span>
<span class="n">line</span> <span class="o">+=</span> <span class="s2">"|"</span>
<span class="nb">print</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"+-------+-------+-------+"</span><span class="p">)</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Weitere_Beispiele">Weitere Beispiele</h2></div>
<p>Für die folgenden Probleme existieren jeweils zahlreiche Optimierungsmodelle, die sich in der Regel jeweils nicht klar dominieren.
</p>
<ul><li>Das <i>Unit-Commitment-Problem</i> (<a href="Kraftwerkseinsatzoptimierung" title="Kraftwerkseinsatzoptimierung">Kraftwerkseinsatz</a>optimierung)<sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Problem_des_Handlungsreisenden" title="Problem des Handlungsreisenden">Das Problem des Handlungsreisenden</a><sup id="cite_ref-:1_2-1" class="reference"><a href="#cite_note-:1-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup>, insbesondere auch die ganzzahligen Formulierungen auf der englischsprachigen Wikipedia-Seite</li>
<li>Zahlreiche Probleme in der chemischen Industrie, der Produktionswirtschaft, Transportwesen, Finanzen, Agrarindustrie, Gesundheitswesen, Personalplanung, Lebensmittelindustrie, Papierindustrie, Supply-Chain-Management, Statistik und Machine Learning<sup id="cite_ref-:3_9-0" class="reference"><a href="#cite_note-:3-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-:2_3-1" class="reference"><a href="#cite_note-:2-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-10" class="reference"><a href="#cite_note-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-:0_1-2" class="reference"><a href="#cite_note-:0-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup></li></ul>
<div class="mw-heading mw-heading2"><h2 id="Modellierungstricks">Modellierungstricks</h2></div>
<p>Die folgenden Modellierungstricks ermöglichen es, Ausdrücke (hoffentlich) vorteilhaft umzuformulieren, um eine bessere Solver-Laufzeit zu erreichen. Es handelt sich hierbei um einfache Tricks. Für fortgeschrittene Tricks wie die approximative Linearisierung oder das Modellieren mit Lazy Constraints und Callback-Funktionen sei auf die weiterführende Literatur verwiesen.<sup id="cite_ref-:2_3-2" class="reference"><a href="#cite_note-:2-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-:0_1-3" class="reference"><a href="#cite_note-:0-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-:3_9-1" class="reference"><a href="#cite_note-:3-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Streng_monotone_Transformationen">Streng monotone Transformationen</h3></div>
<p>Falls <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \theta :\mathbb {R} \to \mathbb {R} }">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>θ<!-- θ --></mi>
<mo>:</mo>
<mrow class="MJX-TeXAtom-ORD">
<mi mathvariant="double-struck">R</mi>
</mrow>
<mo stretchy="false">→<!-- → --></mo>
<mrow class="MJX-TeXAtom-ORD">
<mi mathvariant="double-struck">R</mi>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \theta :\mathbb {R} \to \mathbb {R} }</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/7ec3e4c3b070f92b42d1cf48b3a7eae3849820f8.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:9.998ex; height:2.176ex;" alt="{\displaystyle \theta :\mathbb {R} \to \mathbb {R} }" loading="lazy"></span> eine streng monoton steigende Funktion ist, kann sie auf eine Zielfunktion angewandt werden, ohne die Lage der Optimalpunkte zu verändern. Beispiele:
</p>
<ul><li>Die Optimierungsmodelle <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \min _{a,b}{\sqrt {\sum _{i=1}^{N}(a^{T}x^{i}+b-y_{i})^{2}}}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<munder>
<mo movablelimits="true" form="prefix">min</mo>
<mrow class="MJX-TeXAtom-ORD">
<mi>a</mi>
<mo>,</mo>
<mi>b</mi>
</mrow>
</munder>
<mrow class="MJX-TeXAtom-ORD">
<msqrt>
<munderover>
<mo>∑<!-- ∑ --></mo>
<mrow class="MJX-TeXAtom-ORD">
<mi>i</mi>
<mo>=</mo>
<mn>1</mn>
</mrow>
<mrow class="MJX-TeXAtom-ORD">
<mi>N</mi>
</mrow>
</munderover>
<mo stretchy="false">(</mo>
<msup>
<mi>a</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>T</mi>
</mrow>
</msup>
<msup>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>i</mi>
</mrow>
</msup>
<mo>+</mo>
<mi>b</mi>
<mo>−<!-- − --></mo>
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>i</mi>
</mrow>
</msub>
<msup>
<mo stretchy="false">)</mo>
<mrow class="MJX-TeXAtom-ORD">
<mn>2</mn>
</mrow>
</msup>
</msqrt>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \min _{a,b}{\sqrt {\sum _{i=1}^{N}(a^{T}x^{i}+b-y_{i})^{2}}}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/53440c86718a170b835104bfefe2be7df4e8c60b.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -3.005ex; width:26.3ex; height:8.009ex;" alt="{\displaystyle \min _{a,b}{\sqrt {\sum _{i=1}^{N}(a^{T}x^{i}+b-y_{i})^{2}}}}" loading="lazy"></span> und <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \min _{a,b}\sum _{i=1}^{N}(a^{T}x^{i}+b-y_{i})^{2}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<munder>
<mo movablelimits="true" form="prefix">min</mo>
<mrow class="MJX-TeXAtom-ORD">
<mi>a</mi>
<mo>,</mo>
<mi>b</mi>
</mrow>
</munder>
<munderover>
<mo>∑<!-- ∑ --></mo>
<mrow class="MJX-TeXAtom-ORD">
<mi>i</mi>
<mo>=</mo>
<mn>1</mn>
</mrow>
<mrow class="MJX-TeXAtom-ORD">
<mi>N</mi>
</mrow>
</munderover>
<mo stretchy="false">(</mo>
<msup>
<mi>a</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>T</mi>
</mrow>
</msup>
<msup>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>i</mi>
</mrow>
</msup>
<mo>+</mo>
<mi>b</mi>
<mo>−<!-- − --></mo>
<msub>
<mi>y</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>i</mi>
</mrow>
</msub>
<msup>
<mo stretchy="false">)</mo>
<mrow class="MJX-TeXAtom-ORD">
<mn>2</mn>
</mrow>
</msup>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \min _{a,b}\sum _{i=1}^{N}(a^{T}x^{i}+b-y_{i})^{2}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/487c59e5585ac1f6c67b4078d382923c64b85465.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -3.005ex; width:23.847ex; height:7.343ex;" alt="{\displaystyle \min _{a,b}\sum _{i=1}^{N}(a^{T}x^{i}+b-y_{i})^{2}}" loading="lazy"></span> besitzen dieselben Optimalpunkte <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle (a^{\star },b^{\star })}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mo stretchy="false">(</mo>
<msup>
<mi>a</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>⋆<!-- ⋆ --></mo>
</mrow>
</msup>
<mo>,</mo>
<msup>
<mi>b</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo>⋆<!-- ⋆ --></mo>
</mrow>
</msup>
<mo stretchy="false">)</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle (a^{\star },b^{\star })}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/03b4ad5a0144d32d72670a554515858816748757.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:7.179ex; height:2.843ex;" alt="{\displaystyle (a^{\star },b^{\star })}" loading="lazy"></span>, da das zweite Problem aus erstem durch Quadrieren der Zielfunktion hervorging und das Quadrieren auf allen nichtnegativen Zahlen eine streng monotone Transformation darstellt. Das Problem entspricht dem Minimieren der <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \ell _{2}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msub>
<mi>ℓ<!-- ℓ --></mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>2</mn>
</mrow>
</msub>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \ell _{2}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/85a4571ee9be10bd3c9df2480ab3d280f99e801a.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:2.024ex; height:2.509ex;" alt="{\displaystyle \ell _{2}}" loading="lazy"></span>-Norm des Vorhersagefehlers und ist ein häufig auftretendes Problem in der Statistik (s. <a href="Methode_der_kleinsten_Quadrate" title="Methode der kleinsten Quadrate">Methode der kleinsten Quadrate</a>).</li>
<li>Bei der Berechnung des <a href="Maximum-Likelihood-Methode" title="Maximum-Likelihood-Methode">Maximum-Likelihood-Schätzers</a> der Exponentialverteilung wird statt der Likelihood-Funktion die sogenannte <a href="Log-Likelihood-Funktion" class="mw-redirect" title="Log-Likelihood-Funktion">Log-Likelihood-Funktion</a> minimiert, da sich hier der Maximalpunkt leichter berechnen lässt und das Logarithmieren nichtnegativer Zahlen ebenfalls eine streng monotone Transformation ist.</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Lineare_Umformulierung_von_Produkten">Lineare Umformulierung von Produkten</h3></div>
<p>Produkte zweier Variablen lassen sich linear äquivalent umformulieren, falls mindestens eine der beiden Variablen eine Binärvariable ist.
</p>
<div class="mw-heading mw-heading4"><h4 id="Produkt_zweier_Binärvariablen"><span id="Produkt_zweier_Bin.C3.A4rvariablen"></span>Produkt zweier Binärvariablen</h4></div>
<p>Das Produkt <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x\cdot y}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mo>⋅<!-- ⋅ --></mo>
<mi>y</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x\cdot y}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/13939e6cddd7ba416fd805830d8f5d815c9b4e76.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:4.164ex; height:2.009ex;" alt="{\displaystyle x\cdot y}" loading="lazy"></span> zweier binärer Entscheidungsvariablen <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\textstyle y,z\in \{0,1\}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="false" scriptlevel="0">
<mi>y</mi>
<mo>,</mo>
<mi>z</mi>
<mo>∈<!-- ∈ --></mo>
<mo fence="false" stretchy="false">{</mo>
<mn>0</mn>
<mo>,</mo>
<mn>1</mn>
<mo fence="false" stretchy="false">}</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\textstyle y,z\in \{0,1\}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/1b28e257970b531450b0d6f6e5032dc24b8ea2bb.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:11.802ex; height:2.843ex;" alt="{\textstyle y,z\in \{0,1\}}" loading="lazy"></span> kann linear umformuliert werden, indem es durch zusätzliche kontinuierliche Variable <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle a\in [0,1]}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>a</mi>
<mo>∈<!-- ∈ --></mo>
<mo stretchy="false">[</mo>
<mn>0</mn>
<mo>,</mo>
<mn>1</mn>
<mo stretchy="false">]</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle a\in [0,1]}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/254834e1cbe5c10e41397c0985566bb1cef07712.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:8.723ex; height:2.843ex;" alt="{\displaystyle a\in [0,1]}" loading="lazy"></span> substituiert wird und das Produkt durch die drei Ungleichungen
</p><p><span class="mwe-math-element mwe-math-element-block"><span class="mwe-math-mathml-display mwe-math-mathml-a11y" style="display: none;"><math display="block" xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle y\geq a,\quad z\geq a,\quad y+z-1\leq a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>y</mi>
<mo>≥<!-- ≥ --></mo>
<mi>a</mi>
<mo>,</mo>
<mspace width="1em"></mspace>
<mi>z</mi>
<mo>≥<!-- ≥ --></mo>
<mi>a</mi>
<mo>,</mo>
<mspace width="1em"></mspace>
<mi>y</mi>
<mo>+</mo>
<mi>z</mi>
<mo>−<!-- − --></mo>
<mn>1</mn>
<mo>≤<!-- ≤ --></mo>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle y\geq a,\quad z\geq a,\quad y+z-1\leq a}</annotation>
</semantics>
</math></span></span>
</p><p>ersetzt wird. Per Fallunterscheidungen kann gezeigt werden, dass sich durch obige Formulierung <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/ffd2487510aa438433a2579450ab2b3d557e5edc.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.23ex; height:1.676ex;" alt="{\displaystyle a}" loading="lazy"></span> genauso verhält, wie das Produkt <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x\cdot y}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mo>⋅<!-- ⋅ --></mo>
<mi>y</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x\cdot y}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/13939e6cddd7ba416fd805830d8f5d815c9b4e76.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:4.164ex; height:2.009ex;" alt="{\displaystyle x\cdot y}" loading="lazy"></span>, nämlich null ist, sollte eine der beiden Variablen verschwinden und genau dann eins ist, wenn <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x=y=1}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mo>=</mo>
<mi>y</mi>
<mo>=</mo>
<mn>1</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x=y=1}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/52620e42f1d8b888bc7664321a6e8bf6318d6df8.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:9.845ex; height:2.509ex;" alt="{\displaystyle x=y=1}" loading="lazy"></span> gilt.
</p>
<div class="mw-heading mw-heading4"><h4 id="Produkt_einer_Binärvariable_und_einer_kontinuierlichen_Variable"><span id="Produkt_einer_Bin.C3.A4rvariable_und_einer_kontinuierlichen_Variable"></span>Produkt einer Binärvariable und einer kontinuierlichen Variable</h4></div>
<p>Die nichtlineare Gleichung <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle xy\ =\ a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mi>y</mi>
<mtext>&nbsp;</mtext>
<mo>=</mo>
<mtext>&nbsp;</mtext>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle xy\ =\ a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/e3b297710f7f3a351a64d83c88c03dd18304d362.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:7.975ex; height:2.009ex;" alt="{\displaystyle xy\ =\ a}" loading="lazy"></span> kann auch linear umformuliert werden, wenn <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\textstyle y\in \{0,1\}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="false" scriptlevel="0">
<mi>y</mi>
<mo>∈<!-- ∈ --></mo>
<mo fence="false" stretchy="false">{</mo>
<mn>0</mn>
<mo>,</mo>
<mn>1</mn>
<mo fence="false" stretchy="false">}</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\textstyle y\in \{0,1\}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/67078ecbd6fd870a941032fbe8b42bc308c1f240.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:9.68ex; height:2.843ex;" alt="{\textstyle y\in \{0,1\}}" loading="lazy"></span> gilt und <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x\in [L,U]\subset \mathbb {R} }">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mo>∈<!-- ∈ --></mo>
<mo stretchy="false">[</mo>
<mi>L</mi>
<mo>,</mo>
<mi>U</mi>
<mo stretchy="false">]</mo>
<mo>⊂<!-- ⊂ --></mo>
<mrow class="MJX-TeXAtom-ORD">
<mi mathvariant="double-struck">R</mi>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x\in [L,U]\subset \mathbb {R} }</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/1ec521e30d5bbe1cdfaf153528101bfd30ab6c0b.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:14.64ex; height:2.843ex;" alt="{\displaystyle x\in [L,U]\subset \mathbb {R} }" loading="lazy"></span> für zwei reelle Zahlen <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle L\leq U}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>L</mi>
<mo>≤<!-- ≤ --></mo>
<mi>U</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle L\leq U}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/0e411ab14b677042fa935a3d2e3d01e5803d4f15.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.505ex; width:6.464ex; height:2.343ex;" alt="{\displaystyle L\leq U}" loading="lazy"></span>. In diesem Fall ist der Ausdruck äquivalent zu
</p><p><span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle Ly\ \leq \ a\ \leq \ Uy,\quad x-(1-y)U\ \leq \ a\ \leq x-(1-y)L}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>L</mi>
<mi>y</mi>
<mtext>&nbsp;</mtext>
<mo>≤<!-- ≤ --></mo>
<mtext>&nbsp;</mtext>
<mi>a</mi>
<mtext>&nbsp;</mtext>
<mo>≤<!-- ≤ --></mo>
<mtext>&nbsp;</mtext>
<mi>U</mi>
<mi>y</mi>
<mo>,</mo>
<mspace width="1em"></mspace>
<mi>x</mi>
<mo>−<!-- − --></mo>
<mo stretchy="false">(</mo>
<mn>1</mn>
<mo>−<!-- − --></mo>
<mi>y</mi>
<mo stretchy="false">)</mo>
<mi>U</mi>
<mtext>&nbsp;</mtext>
<mo>≤<!-- ≤ --></mo>
<mtext>&nbsp;</mtext>
<mi>a</mi>
<mtext>&nbsp;</mtext>
<mo>≤<!-- ≤ --></mo>
<mi>x</mi>
<mo>−<!-- − --></mo>
<mo stretchy="false">(</mo>
<mn>1</mn>
<mo>−<!-- − --></mo>
<mi>y</mi>
<mo stretchy="false">)</mo>
<mi>L</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle Ly\ \leq \ a\ \leq \ Uy,\quad x-(1-y)U\ \leq \ a\ \leq x-(1-y)L}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/a4bbf76e76803af72feafb3d1be8c6c5d25ea774.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:53.592ex; height:2.843ex;" alt="{\displaystyle Ly\ \leq \ a\ \leq \ Uy,\quad x-(1-y)U\ \leq \ a\ \leq x-(1-y)L}" loading="lazy"></span>,
</p><p>was ähnlich zum obigen rein binären Fall wieder per Fallunterscheidung verifiziert werden kann.
</p>
<div class="mw-heading mw-heading3"><h3 id="Lineare_Umformulierung_von_Beträgen"><span id="Lineare_Umformulierung_von_Betr.C3.A4gen"></span>Lineare Umformulierung von Beträgen</h3></div>
<p>Während die stückweise lineare Gleichung <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle |x|\leq a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo>≤<!-- ≤ --></mo>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle |x|\leq a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/5c848830eed2a6a288245c81b6138c6e6ec0efad.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:6.952ex; height:2.843ex;" alt="{\displaystyle |x|\leq a}" loading="lazy"></span> leicht durch die äquivalenten beiden linearen Ungleichungen <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x\leq a,\ -x\leq a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mo>≤<!-- ≤ --></mo>
<mi>a</mi>
<mo>,</mo>
<mtext>&nbsp;</mtext>
<mo>−<!-- − --></mo>
<mi>x</mi>
<mo>≤<!-- ≤ --></mo>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x\leq a,\ -x\leq a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/51d84a5f267e6ecde5aa124c4b9ef06245eabab3.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:15.771ex; height:2.343ex;" alt="{\displaystyle x\leq a,\ -x\leq a}" loading="lazy"></span> ersetzt werden kann, gestaltet es sich für <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle |x|\geq a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo>≥<!-- ≥ --></mo>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle |x|\geq a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/09d4303fc39317bea390c6b9326db912e95ccba3.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:6.952ex; height:2.843ex;" alt="{\displaystyle |x|\geq a}" loading="lazy"></span> etwas komplexer. Da <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle |x|\geq a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mi>x</mi>
<mrow class="MJX-TeXAtom-ORD">
<mo stretchy="false">|</mo>
</mrow>
<mo>≥<!-- ≥ --></mo>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle |x|\geq a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/09d4303fc39317bea390c6b9326db912e95ccba3.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:6.952ex; height:2.843ex;" alt="{\displaystyle |x|\geq a}" loading="lazy"></span> äquivalent zur logischen Oder-Aussage <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x\geq a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mo>≥<!-- ≥ --></mo>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x\geq a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/9242a22d6883ac93836f3a51bbd9a6d8bca1ae4c.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.505ex; width:5.658ex; height:2.176ex;" alt="{\displaystyle x\geq a}" loading="lazy"></span> oder <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x\leq -a}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>x</mi>
<mo>≤<!-- ≤ --></mo>
<mo>−<!-- − --></mo>
<mi>a</mi>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle x\leq -a}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/9e6398ab6f67efcc19252e7310e3860ced31ce89.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.505ex; width:7.466ex; height:2.176ex;" alt="{\displaystyle x\leq -a}" loading="lazy"></span> ist, wird dies durch die Einführung einer Binärvariable modelliert, was ausführlicher in der Literatur oder in dem Artikel zur <a href="Gemischt-ganzzahlige_Optimierung#Einfache_Beispiele" title="Gemischt-ganzzahlige Optimierung">gemischt-ganzzahligen Optimierung</a> nachgelesen werden kann.
</p>
<div class="mw-heading mw-heading2"><h2 id="Planungsebenen_in_der_Praxis">Planungsebenen in der Praxis</h2></div>
<p>Für den erfolgreichen Einsatz von Optimierungsmodellen in der Praxis sollte die zeitliche Einordnung sowie die Einbindung in die IT-Infrastruktur beachtet werden.<sup id="cite_ref-:0_1-4" class="reference"><a href="#cite_note-:0-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Zeitlicher_Planungshorizont">Zeitlicher Planungshorizont</h3></div>
<p>Optimierungsmodelle können in der <a href="Operative_Planung" title="Operative Planung">operativen</a>, taktischen oder <a href="Strategische_Planung_(Betriebswirtschaft)" title="Strategische Planung (Betriebswirtschaft)">strategischen Planung</a> eingesetzt werden. Im <i>operativen</i> Geschäft müssen kurzfristig optimale Entscheidungen gefällt werden, wobei der Planungshorizont in der Regel deutlich unter einem Jahr bis hin zu wenigen Stunden oder Minuten liegen kann. Beispiele hierfür sind Optimierungsmodelle in der Produktion, die konkrete Belegungspläne für produzierende Maschinen berechnen.<sup id="cite_ref-11" class="reference"><a href="#cite_note-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup> Die <i>taktische</i> Planung bezieht sich in der Regel auf wenige Jahre und versucht etwa optimale Entscheidungen in Bezug auf die Wertschöpfungskette eines Unternehmens zu treffen.<sup id="cite_ref-12" class="reference"><a href="#cite_note-12"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup> Langristigere Entscheidungen wie etwa optimale Standortplanungen für neue Standorte sind Teil von <i>strategischen</i> Optimierungsmodellen.<sup id="cite_ref-13" class="reference"><a href="#cite_note-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Art_der_IT-Lösung"><span id="Art_der_IT-L.C3.B6sung"></span>Art der IT-Lösung</h3></div>
<p>Ein Optimierungsmodell wird in der Regel in bestehende IT-Infrastruktur eingebettet, wobei mindestens folgende Typen zu unterscheiden sind.<sup id="cite_ref-:0_1-5" class="reference"><a href="#cite_note-:0-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading4"><h4 id="One-Shot-Solution">One-Shot-Solution</h4></div>
<p>Ein Optimierungsmodell, welches als <i>One-Shot-Solution</i> eingesetzt wird, berechnet optimale Lösungen für selten oder unregelmäßig anfallende Aufgaben, deren einmalige Lösung das Problem vorerst erschöpfend behandelt. Ein Beispiel wäre die Layout-Planung einer neu zu errichtenden Produktionshalle eines kleinen oder mittelständischen Unternehmens. Diese Fragestellung kann losgelöst von der bereits existierenden IT-Infrastruktur beantwortet und umgesetzt werden. Auch wenn die anzuwendende Methodik sehr anspruchsvoll sein kann, so ist das Problem aus IT-Sicht angenehm zu handhaben, da keine Software, sondern Ergebnisse in Form von Zahlen produziert werden.
</p>
<div class="mw-heading mw-heading4"><h4 id="Stand-Alone-Solution">Stand-Alone-Solution</h4></div>
<p>Wird ein Optimierungsmodell als <i>Stand-Alone-Solution</i> eingesetzt, so wird darunter ein selbstständiges Stück Software verstanden, in dem Optimierungskomponenten integriert sind, das jedoch IT-seitig eher losgelöst von der bestehenden Infrastruktur funktioniert. Ein Beispiel dafür wäre ein <a href="Project_Jupyter" title="Project Jupyter">Jupyter Notebook</a> oder eine <a href="Webanwendung" title="Webanwendung">Web-Applikation</a>, deren Daten in Form von CSV-Dateien zur Verfügung gestellt werden. Das Ergebnis ist ein Tool, das, vergleichbar zu Excel-Dateien, zur Verfügung steht, um damit Analysen durchzuführen. Der Datenfluss ist jedoch nicht vollständig automatisiert, sodass sich diese Art von Lösung für wiederkehrende Aufgaben niedriger Frequenz eventuell anbieten kann.
</p>
<div class="mw-heading mw-heading4"><h4 id="Fully-Flegded-Solution">Fully-Flegded-Solution</h4></div>
<p>Ist ein Optimierungsmodell Teil einer <i>Fully-Flegded-Solution</i>, so handelt es sich dabei um eine vollständig integrierte Lösung, die automatisiert Daten erhält und produziert. Aufgrund des hohen Automatisierungsgrades sind in der Regel viele Pre- und Postprocessing-Schritte notwendig, um ein hohes Sicherheitslevel garantieren zu können. Dies resultiert idealerweise in einem hochproduktiven und skalierbaren System, das auch im operativen Betrieb für einen hohen Mehrwert sorgen kann, nachdem die hohen IT-Hürden bei der Einführung des Systems und der Schulung der Nutzer gemeistert wurden.
</p>
<div class="mw-heading mw-heading2"><h2 id="Weiterführende_Literatur"><span id="Weiterf.C3.BChrende_Literatur"></span>Weiterführende Literatur</h2></div>
<p>Bücher:
</p>
<ul><li>J. Kallrath: <i><a rel="nofollow" class="external text" href="https://link.springer.com/book/10.1007/978-3-658-00690-7">Gemischt-ganzzahlige Optimierung: Modellierung in der Praxis</a></i>, 2. Auflage. Springer Spektrum, Berlin, Heidelberg, 2013, ISBN 978-3-658-00689-1</li>
<li>N. Sudermann-Merx: <i><a rel="nofollow" class="external text" href="https://link.springer.com/book/10.1007/978-3-662-67381-2">Einführung in Optimierungsmodelle</a>.</i> Springer Spektrum, Berlin, Heidelberg, 2023, ISBN 978-3-662-67380-5.</li>
<li>H. P. Williams: <i><a rel="nofollow" class="external text" href="https://www.wiley.com/en-us/Model+Building+in+Mathematical+Programming%2C+5th+Edition-p-9781118443330">Model Building in Mathematical Programming</a></i>, 5. Auflage. John Wiley &amp; Sons, Hoboken, New Jersey 2020, ISBN 978-1-118-44333-0.</li></ul>
<p>Blogs/Weblinks:
</p>
<ul><li>E. Kalvelagen: <a rel="nofollow" class="external free" href="https://yetanothermathprogrammingconsultant.blogspot.com/">https://yetanothermathprogrammingconsultant.blogspot.com/</a></li>
<li>T. Hürlimann: <a rel="nofollow" class="external free" href="https://matmod.ch/">https://matmod.ch/</a></li></ul>
<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>
<ol class="references">
<li id="cite_note-:0-1"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-:0_1-0">a</a></sup> <sup><a href="#cite_ref-:0_1-1">b</a></sup> <sup><a href="#cite_ref-:0_1-2">c</a></sup> <sup><a href="#cite_ref-:0_1-3">d</a></sup> <sup><a href="#cite_ref-:0_1-4">e</a></sup> <sup><a href="#cite_ref-:0_1-5">f</a></sup></span> <span class="reference-text">Nathan Georg Sudermann-Merx: <cite style="font-style:italic">Einführung in Optimierungsmodelle: mit Beispielen und Real-World-Anwendungen in Python</cite>. Springer Spektrum, Berlin / Heidelberg 2023, ISBN 978-3-662-67380-5.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.au=Nathan+Georg+Sudermann-Merx&amp;rft.btitle=Einf%C3%BChrung+in+Optimierungsmodelle%3A+mit+Beispielen+und+Real-World-Anwendungen+in+Python&amp;rft.date=2023&amp;rft.genre=book&amp;rft.isbn=9783662673805&amp;rft.place=Berlin+%2F+Heidelberg&amp;rft.pub=Springer+Spektrum" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-:1-2"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-:1_2-0">a</a></sup> <sup><a href="#cite_ref-:1_2-1">b</a></sup></span> <span class="reference-text">David L. Applegate, Robert E. Bixby, Vašek Chvatál, William J. Cook: <cite style="font-style:italic">The traveling salesman problem: a computational study</cite> (=&nbsp;<cite style="font-style:italic">Princeton series in applied mathematics</cite>). Princeton university press, Princeton (N.J.) 2006, ISBN 978-0-691-12993-8.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.au=David+L.+Applegate%2C+Robert+E.+Bixby%2C+Va%C5%A1ek+Chvat%C3%A1l%2C+...&amp;rft.btitle=The+traveling+salesman+problem%3A+a+computational+study&amp;rft.date=2006&amp;rft.genre=book&amp;rft.isbn=9780691129938&amp;rft.place=Princeton+%28N.J.%29&amp;rft.pub=Princeton+university+press&amp;rft.series=Princeton+series+in+applied+mathematics" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-:2-3"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-:2_3-0">a</a></sup> <sup><a href="#cite_ref-:2_3-1">b</a></sup> <sup><a href="#cite_ref-:2_3-2">c</a></sup></span> <span class="reference-text">Josef Kallrath: <cite style="font-style:italic">Gemischt-ganzzahlige Optimierung: Modellierung in der Praxis</cite> (=&nbsp;<cite style="font-style:italic">Lehrbuch</cite>). 2., überarbeitete und erweiterte Auflage. Springer Spektrum, Wiesbaden 2013, ISBN 978-3-658-00689-1.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.au=Josef+Kallrath&amp;rft.btitle=Gemischt-ganzzahlige+Optimierung%3A+Modellierung+in+der+Praxis&amp;rft.date=2013&amp;rft.edition=2.%2C+%C3%BCberarbeitete+und+erweiterte&amp;rft.genre=book&amp;rft.isbn=9783658006891&amp;rft.place=Wiesbaden&amp;rft.pub=Springer+Spektrum&amp;rft.series=Lehrbuch" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><a href="#cite_ref-4">↑</a></span> <span class="reference-text">Tobias Achterberg, Robert E. Bixby, Zonghao Gu, Edward Rothberg, Dieter Weninger: <cite style="font-style:italic">Presolve Reductions in Mixed Integer Programming</cite>. In: <cite style="font-style:italic">INFORMS Journal on Computing</cite>. <span style="white-space:nowrap">Band<span style="display:inline-block;width:.2em">&nbsp;</span>32</span>, <span style="white-space:nowrap">Nr.<span style="display:inline-block;width:.2em">&nbsp;</span>2</span>, April 2020, <a href="Internationale_Standardnummer_f%C3%BCr_fortlaufende_Sammelwerke" title="Internationale Standardnummer für fortlaufende Sammelwerke">ISSN</a>&nbsp;<span style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://zdb-katalog.de/list.xhtml?t=iss%3D%221091-9856%22&amp;key=cql">1091-9856</a></span>, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>473–506</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1287/ijoc.2018.0857">10.1287/ijoc.2018.0857</a></span> (<a rel="nofollow" class="external text" href="https://opus4.kobv.de/opus4-zib/files/6037/Presolve.pdf">kobv.de</a> [PDF; abgerufen am 29.&nbsp;Dezember 2023]).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.atitle=Presolve+Reductions+in+Mixed+Integer+Programming&amp;rft.au=Tobias+Achterberg%2C+Robert+E.+Bixby%2C+Zonghao+Gu%2C+...&amp;rft.date=2020-04&amp;rft.doi=10.1287%2Fijoc.2018.0857&amp;rft.genre=journal&amp;rft.issn=1091-9856&amp;rft.issue=2&amp;rft.jtitle=INFORMS+Journal+on+Computing&amp;rft.pages=473-506&amp;rft.volume=32" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-5"><span class="mw-cite-backlink"><a href="#cite_ref-5">↑</a></span> <span class="reference-text">Laurence A. Wolsey: <cite style="font-style:italic">Integer programming</cite>. 2. Auflage. Wiley, Hoboken, NJ Chichester, West Sussex 2021, ISBN 978-1-119-60653-6.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.au=Laurence+A.+Wolsey&amp;rft.btitle=Integer+programming&amp;rft.date=2021&amp;rft.edition=2.&amp;rft.genre=book&amp;rft.isbn=9781119606536&amp;rft.place=Hoboken%2C+NJ+Chichester%2C+West+Sussex&amp;rft.pub=Wiley" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><a href="#cite_ref-6">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="https://github.com/spiralulam/intro_opt_models/tree/main/code/chapter_5_MILP/sudoku"><i>intro_opt_models/code/chapter_5_MILP/sudoku at main · spiralulam/intro_opt_models.</i></a><span class="Abrufdatum"> Abgerufen am 29.&nbsp;Dezember 2023</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3AOptimierungsmodell&amp;rft.title=intro_opt_models%2Fcode%2Fchapter_5_MILP%2Fsudoku+at+main+%C2%B7+spiralulam%2Fintro_opt_models&amp;rft.description=intro_opt_models%2Fcode%2Fchapter_5_MILP%2Fsudoku+at+main+%C2%B7+spiralulam%2Fintro_opt_models&amp;rft.identifier=https%3A%2F%2Fgithub.com%2Fspiralulam%2Fintro_opt_models%2Ftree%2Fmain%2Fcode%2Fchapter_5_MILP%2Fsudoku&amp;rft.language=en">&nbsp;</span></span>
</li>
<li id="cite_note-7"><span class="mw-cite-backlink"><a href="#cite_ref-7">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="https://www.python-mip.com/"><i>Python-MIP.</i></a><span class="Abrufdatum"> Abgerufen am 29.&nbsp;Dezember 2023</span>.</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3AOptimierungsmodell&amp;rft.title=Python-MIP&amp;rft.description=Python-MIP&amp;rft.identifier=https%3A%2F%2Fwww.python-mip.com%2F">&nbsp;</span></span>
</li>
<li id="cite_note-8"><span class="mw-cite-backlink"><a href="#cite_ref-8">↑</a></span> <span class="reference-text">Bernard Knueven, James Ostrowski, Jean-Paul Watson: <cite style="font-style:italic">On Mixed-Integer Programming Formulations for the Unit Commitment Problem</cite>. In: <cite style="font-style:italic">INFORMS Journal on Computing</cite>. 25.&nbsp;Juni 2020, <a href="Internationale_Standardnummer_f%C3%BCr_fortlaufende_Sammelwerke" title="Internationale Standardnummer für fortlaufende Sammelwerke">ISSN</a>&nbsp;<span style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://zdb-katalog.de/list.xhtml?t=iss%3D%221091-9856%22&amp;key=cql">1091-9856</a></span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1287/ijoc.2019.0944">10.1287/ijoc.2019.0944</a></span> (<a rel="nofollow" class="external text" href="https://optimization-online.org/wp-content/uploads/2018/11/6930.pdf">optimization-online.org</a> [PDF; abgerufen am 30.&nbsp;Dezember 2023]).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.atitle=On+Mixed-Integer+Programming+Formulations+for+the+Unit+Commitment+Problem&amp;rft.au=Bernard+Knueven%2C+James+Ostrowski%2C+Jean-Paul+Watson&amp;rft.date=2020-06-25&amp;rft.doi=10.1287%2Fijoc.2019.0944&amp;rft.genre=journal&amp;rft.issn=1091-9856&amp;rft.jtitle=INFORMS+Journal+on+Computing" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-:3-9"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-:3_9-0">a</a></sup> <sup><a href="#cite_ref-:3_9-1">b</a></sup></span> <span class="reference-text">Hilary P. Williams: <cite style="font-style:italic">Model building in mathematical programming</cite>. 5. Auflage. John Wiley &amp; Sons Ltd, Chichester 2013, ISBN 978-1-118-44333-0 (<a rel="nofollow" class="external text" href="https://www.researchgate.net/file.PostFileLoader.html?id=546b5d0bd685cc9e2b8b45d4&amp;assetKey=AS:273636437495809@1442251418466">researchgate.net</a> [abgerufen am 30.&nbsp;Dezember 2023]).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.au=Hilary+P.+Williams&amp;rft.btitle=Model+building+in+mathematical+programming&amp;rft.date=2013&amp;rft.edition=5.&amp;rft.genre=book&amp;rft.isbn=9781118443330&amp;rft.place=Chichester&amp;rft.pub=John+Wiley+%26+Sons+Ltd" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-10"><span class="mw-cite-backlink"><a href="#cite_ref-10">↑</a></span> <span class="reference-text"><span class="cite"><a rel="nofollow" class="external text" href="https://yetanothermathprogrammingconsultant.blogspot.com/"><i>Yet Another Math Programming Consultant.</i></a><span class="Abrufdatum"> Abgerufen am 30.&nbsp;Dezember 2023</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3AOptimierungsmodell&amp;rft.title=Yet+Another+Math+Programming+Consultant&amp;rft.description=Yet+Another+Math+Programming+Consultant&amp;rft.identifier=https%3A%2F%2Fyetanothermathprogrammingconsultant.blogspot.com%2F&amp;rft.language=en">&nbsp;</span></span>
</li>
<li id="cite_note-11"><span class="mw-cite-backlink"><a href="#cite_ref-11">↑</a></span> <span class="reference-text">Christodoulos A. Floudas, Xiaoxia Lin: <cite style="font-style:italic">Mixed Integer Linear Programming in Process Scheduling: Modeling, Algorithms, and Applications</cite>. In: <cite style="font-style:italic">Annals of Operations Research</cite>. <span style="white-space:nowrap">Band<span style="display:inline-block;width:.2em">&nbsp;</span>139</span>, <span style="white-space:nowrap">Nr.<span style="display:inline-block;width:.2em">&nbsp;</span>1</span>, Oktober 2005, <a href="Internationale_Standardnummer_f%C3%BCr_fortlaufende_Sammelwerke" title="Internationale Standardnummer für fortlaufende Sammelwerke">ISSN</a>&nbsp;<span style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://zdb-katalog.de/list.xhtml?t=iss%3D%220254-5330%22&amp;key=cql">0254-5330</a></span>, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>131–162</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1007/s10479-005-3446-x">10.1007/s10479-005-3446-x</a></span> (<a rel="nofollow" class="external text" href="https://lin.engin.umich.edu/wp-content/uploads/sites/551/2021/10/Mixed-Integer-Linear-Programming-in-Process-Scheduling.pdf">umich.edu</a> [PDF; abgerufen am 30.&nbsp;Dezember 2023]).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.atitle=Mixed+Integer+Linear+Programming+in+Process+Scheduling%3A+Modeling%2C+Algorithms%2C+and+Applications&amp;rft.au=Christodoulos+A.+Floudas%2C+Xiaoxia+Lin&amp;rft.date=2005-10&amp;rft.doi=10.1007%2Fs10479-005-3446-x&amp;rft.genre=journal&amp;rft.issn=0254-5330&amp;rft.issue=1&amp;rft.jtitle=Annals+of+Operations+Research&amp;rft.pages=131-162&amp;rft.volume=139" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-12"><span class="mw-cite-backlink"><a href="#cite_ref-12">↑</a></span> <span class="reference-text">Nazanin Shabani, Taraneh Sowlati: <cite style="font-style:italic">A mixed integer non-linear programming model for tactical value chain optimization of a wood biomass power plant</cite>. In: <cite style="font-style:italic">Applied Energy</cite>. <span style="white-space:nowrap">Band<span style="display:inline-block;width:.2em">&nbsp;</span>104</span>, April 2013, <a href="Internationale_Standardnummer_f%C3%BCr_fortlaufende_Sammelwerke" title="Internationale Standardnummer für fortlaufende Sammelwerke">ISSN</a>&nbsp;<span style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://zdb-katalog.de/list.xhtml?t=iss%3D%220306-2619%22&amp;key=cql">0306-2619</a></span>, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>353–361</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1016/j.apenergy.2012.11.013">10.1016/j.apenergy.2012.11.013</a></span>.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.atitle=A+mixed+integer+non-linear+programming+model+for+tactical+value+chain+optimization+of+a+wood+biomass+power+plant&amp;rft.au=Nazanin+Shabani%2C+Taraneh+Sowlati&amp;rft.date=2013-04&amp;rft.doi=10.1016%2Fj.apenergy.2012.11.013&amp;rft.genre=journal&amp;rft.issn=0306-2619&amp;rft.jtitle=Applied+Energy&amp;rft.pages=353-361&amp;rft.volume=104" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-13"><span class="mw-cite-backlink"><a href="#cite_ref-13">↑</a></span> <span class="reference-text">Hong Yan, Zhenxin Yu, T.C. Edwin Cheng: <cite style="font-style:italic">A strategic model for supply chain design with logical constraints: formulation and solution</cite>. In: <cite style="font-style:italic">Computers &amp; Operations Research</cite>. <span style="white-space:nowrap">Band<span style="display:inline-block;width:.2em">&nbsp;</span>30</span>, <span style="white-space:nowrap">Nr.<span style="display:inline-block;width:.2em">&nbsp;</span>14</span>, Dezember 2003, <a href="Internationale_Standardnummer_f%C3%BCr_fortlaufende_Sammelwerke" title="Internationale Standardnummer für fortlaufende Sammelwerke">ISSN</a>&nbsp;<span style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://zdb-katalog.de/list.xhtml?t=iss%3D%220305-0548%22&amp;key=cql">0305-0548</a></span>, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>2135–2155</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1016/s0305-0548%2802%2900127-2">10.1016/s0305-0548(02)00127-2</a></span>.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rfr_id=info:sid/de.wikipedia.org:Optimierungsmodell&amp;rft.atitle=A+strategic+model+for+supply+chain+design+with+logical+constraints%3A+formulation+and+solution&amp;rft.au=Hong+Yan%2C+Zhenxin+Yu%2C+T.C.+Edwin+Cheng&amp;rft.date=2003-12&amp;rft.doi=10.1016%2Fs0305-0548%2802%2900127-2&amp;rft.genre=journal&amp;rft.issn=0305-0548&amp;rft.issue=14&amp;rft.jtitle=Computers+%26amp%3B+Operations+Research&amp;rft.pages=2135-2155&amp;rft.volume=30" style="display:none">&nbsp;</span></span>
</li>
</ol></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-09-21" href="https://de.wikipedia.org/wiki/?title=Optimierungsmodell&amp;oldid=259924471">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>

</body></html>